/***************************************************************************************
* Copyright (c) 2014-2022 Zihao Yu, Nanjing University
*
* NEMU is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*          http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
*
* See the Mulan PSL v2 for more details.
***************************************************************************************/

#include <isa.h>
#include <cpu/cpu.h>
#include <readline/readline.h>
#include <readline/history.h>
#include "sdb.h"
#include <memory/paddr.h>
static int is_batch_mode = false;

void init_regex();
void init_wp_pool();

/* We use the `readline' library to provide more flexibility to read from stdin. */
static char* rl_gets() {
  static char *line_read = NULL;

  if (line_read) {
    free(line_read);
    line_read = NULL;
  }

  line_read = readline("(nemu) ");

  if (line_read && *line_read) {
    add_history(line_read);
  }

  return line_read;
}

static int cmd_c(char *args) {
  cpu_exec(-1);
  return 0;
}


static int cmd_q(char *args) {
  nemu_state.state=NEMU_QUIT;  //add this line for directly exit
  return -1;
}
static int cmd_p(char *args){
  bool success;
  char *arg = strtok(NULL, " ");
  if(arg != NULL){
    uint32_t val = expr(arg,&success);
    if(success == true){
      printf("%d\n",val);
    }else{
      assert(0);
    }
  }else{
    assert(0);
  }
  return 0;
}
static int cmd_w(char *args){
  char *arg = strtok(NULL, " ");
  if(arg != NULL){
    WP* node = new_wp();
    memcpy(node->str,arg,strlen(arg)+1);
    bool success;
    uint32_t val = expr(arg,&success);
    if(success == true){
      node->val = val;
    }
    else{
      assert(0);
    }
    printf("Hardware watchpoint %d: %s\n",node->NO,arg);
    add_head(node);
  }
  else{
    assert(0);
  }
  return 0;
}
static int cmd_d(char *args){
  char *arg = strtok(NULL, " ");
  if(arg != NULL){
    WP* node = get_head();
    while(node != NULL){
      if(node->NO == atoi(arg)){
        free_wp(node);
        break;
      }
      node = node->next;
    }
  }
  return 0;
}

static int cmd_help(char *args);
static int cmd_si(char *args);
static int cmd_info(char *args);
static int cmd_x(char *args);
static int cmd_p(char *args);
static int cmd_w(char *args);
static int cmd_d(char *args);
static struct {
  const char *name;
  const char *description;
  int (*handler) (char *);
} cmd_table [] = {
  { "help", "Display information about all supported commands", cmd_help },
  { "c", "Continue the execution of the program", cmd_c },
  { "q", "Exit NEMU", cmd_q },
  {"si", "Step", cmd_si},
  {"info", "Info the state", cmd_info},
  {"x", "Scan memory", cmd_x},
  /* TODO: Add more commands */
  {"p", "Print expression", cmd_p},
  {"w", "Set watchpoint", cmd_w},
  {"d", "Delete watchpoint", cmd_d},
};

static int cmd_si(char *args){
  char *arg = strtok(NULL," ");
  if (arg == NULL){
    cpu_exec(1); //execute 1 time
  }
  else {
    cpu_exec(atoi(arg)); //execute n time
  }
  return 0;
}
static int cmd_info(char *args){
  char *arg = strtok(NULL, " ");
  if(arg != NULL){
    if (strcmp(arg,"r") == 0){
      isa_reg_display();
    }
    else {
      if(strcmp(arg,"w")==0){
        printf("%-8s %-12s %-10s %-10s\n", "Num", "Type", "Enabled", "Address");
        WP* node = get_head();
        while(node!=NULL){
          printf("%-8d %-12s %-10s %-10s\n", node->NO, "watchpoint", "y", node->str);
          node = node->next;
        }
          
        }
      else{
        assert(0);
      }
    }
  }
  return 0;
}
static int cmd_x(char *args){
  char *arg = strtok(NULL, " ");
  if (arg != NULL){
    int n = atoi(arg); // n bytes
    arg = strtok(NULL, " ");
    if (arg != NULL){
      uint32_t addr;
      sscanf(arg, "%x",&addr);
      printf("the pmem 0  is %x\n",guest_to_host(RESET_VECTOR)[0]);
      for (int i = 0; i < n; i ++){
        printf("0x%x 0x%08x\n",(addr+4*i),paddr_read(addr+4*i,4));
      }
    }
  }
  return 0;
}
#define NR_CMD ARRLEN(cmd_table)

static int cmd_help(char *args) {
  /* extract the first argument */
  char *arg = strtok(NULL, " ");
  int i;

  if (arg == NULL) {
    /* no argument given */
    for (i = 0; i < NR_CMD; i ++) {
      printf("%s - %s\n", cmd_table[i].name, cmd_table[i].description);
    }
  }
  else {
    for (i = 0; i < NR_CMD; i ++) {
      if (strcmp(arg, cmd_table[i].name) == 0) {
        printf("%s - %s\n", cmd_table[i].name, cmd_table[i].description);
        return 0;
      }
    }
    printf("Unknown command '%s'\n", arg);
  }
  return 0;
}

void sdb_set_batch_mode() {
  is_batch_mode = true;
}

void sdb_mainloop() {
  if (is_batch_mode) {
    cmd_c(NULL);
    return;
  }

  for (char *str; (str = rl_gets()) != NULL; ) {
    char *str_end = str + strlen(str);

    /* extract the first token as the command */
    char *cmd = strtok(str, " ");
    if (cmd == NULL) { continue; }

    /* treat the remaining string as the arguments,
     * which may need further parsing
     */
    char *args = cmd + strlen(cmd) + 1;
    if (args >= str_end) {
      args = NULL;
    }

#ifdef CONFIG_DEVICE
    extern void sdl_clear_event_queue();
    sdl_clear_event_queue();
#endif

    int i;
    for (i = 0; i < NR_CMD; i ++) {
      if (strcmp(cmd, cmd_table[i].name) == 0) {
        if (cmd_table[i].handler(args) < 0) { return; }
        break;
      }
    }

    if (i == NR_CMD) { printf("Unknown command '%s'\n", cmd); }
  }
}

void test_expr(){
  FILE *fp = fopen("/home/zeract/ics2022/nemu/tools/gen-expr/build/input","r");
  if(fp==NULL){
    assert(0);
  }
  char line[65535];
    while (fgets(line, sizeof(line), fp)) {
      
        // 每行的格式是 "<result> <expression>"
        unsigned result;
        char expression[65535];
        if (sscanf(line, "%u %[^\n]", &result, expression) == 2) {
            bool success;
            unsigned val = expr(expression,&success);
            if(success){
              Log("result is %u\n",val);
              assert(val==result);
            }
        }
    }
  fclose(fp);

}

void init_sdb() {
  /* Compile the regular expressions. */
  init_regex();
  // test the expression 
  // test_expr();
  /* Initialize the watchpoint pool. */
  init_wp_pool();
}
